# 导入必要的库
import numpy as np
import pandas as pd
import seaborn as sns
from matplotlib import pyplot as plt

from collections import Counter
from matplotlib import rcParams



# 更新 Matplotlib 默认字体配置
rcParams['font.family'] = 'sans-serif'
rcParams['font.sans-serif'] = ['SimHei']  # 使用黑体作为 sans-serif 的默认字体
rcParams['axes.unicode_minus'] = False  # 解决坐标轴负号显示问题

# 导入所需的库
import pandas as pd

# 读取数据文件
blob_df = pd.read_csv("./训练集/blob.csv")  # 读取blob.csv文件并将数据存储在blob_df中
dart_df = pd.read_csv("./训练集/dart.csv")  # 读取dart.csv文件并将数据存储在dart_df中
outliers_df = pd.read_csv("./训练集/outliers.csv")  # 读取outliers.csv文件并将数据存储在outliers_df中
spiral2_df = pd.read_csv("./训练集/spiral2.csv")  # 读取spiral2.csv文件并将数据存储在spiral2_df中
basic2_df = pd.read_csv("./训练集/basic2.csv")  # 读取basic2.csv文件并将数据存储在basic2_df中
boxes3_df = pd.read_csv("./训练集/boxes3.csv")  # 读取boxes3.csv文件并将数据存储在boxes3_df中

raw_df = pd.read_csv("./测试集/data.csv", encoding='unicode_escape')  # 读取Online_Retail.csv文件并将数据存储在raw_df中，使用unicode_escape编码解决编码问题


#可视化展示
#可视化展示
#可视化展示
#可视化展示
#可视化展示


# 创建子图

fig, axes = plt.subplots(nrows=2, ncols=3,figsize=(13,13))

# 设置整个图的标题
fig.suptitle('EXERCISE 训练集 SETS\n', size = 18)

# 在第一个子图中绘制散点图，x轴为blob_df的x列，y轴为blob_df的y列，颜色根据blob_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
# 设置第一个子图的标题
axes[0,0].set_title("Blob");

# 在第二个子图中绘制散点图，x轴为dart_df的x列，y轴为dart_df的y列，颜色根据dart_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[0,1].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
# 设置第二个子图的标题
axes[0,1].set_title("Dart");

# 在第三个子图中绘制散点图，x轴为basic2_df的x列，y轴为basic2_df的y列，颜色根据basic2_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[0,2].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
# 设置第三个子图的标题
axes[0,2].set_title("Basic");

# 在第四个子图中绘制散点图，x轴为outliers_df的x列，y轴为outliers_df的y列，颜色根据outliers_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[1,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
# 设置第四个子图的标题
axes[1,0].set_title("Outliers");

# 在第五个子图中绘制散点图，x轴为spiral2_df的x列，y轴为spiral2_df的y列，颜色根据spiral2_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[1,1].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
# 设置第五个子图的标题
axes[1,1].set_title("Spiral");

# 在第六个子图中绘制散点图，x轴为boxes3_df的x列，y轴为boxes3_df的y列，颜色根据boxes3_df的color列确定，点的大小为10，颜色映射为"Set3"
axes[1,2].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
# 设置第六个子图的标题
axes[1,2].set_title("Boxes");

# 调整子图的布局
plt.tight_layout()
plt.show()


#特征工程
#特征工程
#特征工程
#特征工程
#特征工程


# 对数据框进行描述性统计分析，包括所有列的统计信息
raw_df.describe(include='all')
print(raw_df)
# 删除指定列
raw_df.drop(['StockCode', 'InvoiceDate','Description','Country'],axis = 1, inplace =True)

# 输出处理后的数据
print(raw_df)

# 打印出原始数据中"Quantity"列的最小值
print(raw_df["Quantity"].min())

# 打印出原始数据中"UnitPrice"列的最小值
print(raw_df["UnitPrice"].min())

# 从原始数据框中筛选出数量大于0的数据
df = raw_df.loc[raw_df["Quantity"] > 0]

# 从筛选后的数据框中再次筛选出单价大于0的数据
df = df.loc[df["UnitPrice"] > 0]

# 打印训练集Frame中"Quantity"列的最小值
print(df["Quantity"].min())

# 打印训练集Frame中"UnitPrice"列的最小值
print(df["UnitPrice"].min())

# 创建一个新的列Total，用于存储每个产品的总金额
df["Total"] = df["Quantity"] * df["UnitPrice"]



# 删除数据框中的'Quantity'和'UnitPrice'列
df.drop(['Quantity', 'UnitPrice'], axis=1, inplace=True)
# 检查数据中的缺失值
queshi=df.isnull().sum()
print(queshi)


# 删除具有缺失值的customerId列
df.dropna(axis=0, inplace=True)

# axis=0表示按行删除，inplace=True表示在原始训练集Frame上进行修改




#创建新特征
#频率：交易总数
#金额：交易总金额




# 对数据框df按照'CustomerID'进行分组，计算每个顾客的'Total'总和
Amount = df.groupby('CustomerID')['Total'].sum()

# 重置索引，将'CustomerID'变为列
Amount = Amount.reset_index()

# 将列名改为'CustomerID'和'Amount'
Amount.columns=['CustomerID','Amount']

# 对数据框df按照'CustomerID'进行分组，计算每个顾客的'InvoiceNo'计数
Frequency=df.groupby('CustomerID')['InvoiceNo'].count()

# 重置索引，将'CustomerID'变为列
Frequency=Frequency.reset_index()

# 将列名改为'CustomerID'和'Frequency'
Frequency.columns=['CustomerID','Frequency']

# 将Amount和Frequency两个数据框按照'CustomerID'进行内连接合并
df1 = pd.merge(Amount, Frequency, on='CustomerID', how='inner')

# 显示合并后的前几行数据
print(df1.head())



#异常值检测
#异常值检测
#异常值检测
#异常值检测
#异常值检测



# 使用describe函数对df1进行描述性统计分析
# 参数include='all'表示包括所有数据类型的统计结果
dd=df1.describe(include='all')
print(dd)

# 创建一个包含1行2列的图表，并设置图表的大小为6x6
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6,6))

# 设置整个图表的标题为"Outliers"，并设置标题的字体大小为25
fig.suptitle('Outliers\n', size=25)

# 在第一个子图中绘制一个箱线图，数据为df1['Amount']，颜色使用'Spectral'调色板，同时设置子图的标题为"Amount"
sns.boxplot(ax=axes[0], 训练集=df1['Amount'], palette='Spectral').set_title("Amount")

# 在第二个子图中绘制一个箱线图，数据为df1['Frequency']，颜色使用'Spectral'调色板，同时设置子图的标题为"Frequency"
sns.boxplot(ax=axes[1], 训练集=df1['Frequency'], palette='Spectral').set_title("Frequency")

# 调整子图的布局，使得子图之间没有重叠
plt.tight_layout()

# 导入IsolationForest模块
from sklearn.ensemble import IsolationForest

# 复制df1数据框到df2
df2 = df1.copy()



# 创建IsolationForest模型，设置参数n_estimators为150，max_samples为'auto'，contamination为0.1，max_features为1.0
model = IsolationForest(n_estimators=150, max_samples='auto', contamination=float(0.1), max_features=1.0)

# 使用模型对数据进行训练
model.fit(df2)

# 给df添加'scores'和'anomaly'列
scores = model.decision_function(df2)  # 使用模型的decision_function方法计算每个样本的异常分数
anomaly = model.predict(df2)  # 使用模型的predict方法预测每个样本的异常标签
df2['scores'] = scores  # 将异常分数添加到df的'scores'列
df2['anomaly'] = anomaly  # 将异常标签添加到df的'anomaly'列

anomaly = df2.loc[df2['anomaly'] == -1]  # 从df中筛选出异常样本
anomaly_index = list(anomaly.index)  # 获取异常样本的索引列表
print('Total number of outliers is:', len(anomaly))  # 打印异常样本的总数

# 以上代码的作用是使用一个模型对数据集df2进行异常检测，并将异常分数和异常标签添加到df2中。
# 首先，使用模型的decision_function方法计算每个样本的异常分数，并使用模型的predict方法预测每个样本的异常标签。
# 然后，将异常分数添加到df2的'scores'列，将异常标签添加到df2的'anomaly'列。
# 接着，从df2中筛选出异常样本，并将其索引保存在anomaly_index列表中。
# 最后，打印异常样本的总数。

df2 = df2.drop(anomaly_index, axis = 0).reset_index(drop=True)
print(df2.head())



# 创建一个包含1行2列的图表，大小为6x6
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(6,6))

# 设置图表的标题
fig.suptitle('Outliers\n', size = 25)

# 在第一个子图中绘制箱线图，数据为df2['Amount']，颜色使用'Spectral'调色板，设置标题为"Amount"
sns.boxplot(ax=axes[0], 训练集=df2['Amount'], palette='Spectral').set_title("Amount")

# 在第二个子图中绘制箱线图，数据为df2['Frequency']，颜色使用'Spectral'调色板，设置标题为"Frequency"
sns.boxplot(ax=axes[1], 训练集=df2['Frequency'], palette='Spectral').set_title("Frequency")

# 调整子图的布局，使其紧凑显示
plt.tight_layout()
plt.show()
# # 删除不再需要的列
# #df.drop(['scores', 'anomaly'], axis=1, inplace=True)




#数据伸缩
#数据伸缩
#数据伸缩
#数据伸缩
#数据伸缩



# 导入StandardScaler类
from sklearn.preprocessing import StandardScaler

# 创建StandardScaler对象
scaler = StandardScaler()

# 使用StandardScaler对象对df2进行标准化处理，并将结果保存到df3中
df3 = scaler.fit_transform(df2)



#确定最佳聚类数
#确定最佳聚类数
#确定最佳聚类数
#确定最佳聚类数
#确定最佳聚类数
#确定最佳聚类数

#肘部法则
#肘部法则
#肘部法则


# 导入KMeans聚类算法
from sklearn.cluster import KMeans

# 创建一个空列表，用于存储每个簇内平方和的值
wcss = []

# 循环1到10，分别计算每个簇内平方和的值，并将其添加到wcss列表中
for i in range(1, 11):
    # 创建KMeans聚类算法对象，设置聚类数为i，初始化方式为k-means++，随机种子为42
    kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
    
    # 使用KMeans算法对数据进行聚类
    kmeans.fit(df3)
    
    # 将每个簇内平方和的值添加到wcss列表中
    wcss.append(kmeans.inertia_)

# 绘制聚类数与簇内平方和的关系图
plt.plot(range(1, 11), wcss)
plt.title('The Elbow Method')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS')
plt.show()

# 导入KMeans类和KElbowVisualizer类
from yellowbrick.cluster import KElbowVisualizer
model = KMeans() # 创建一个KMeans对象

# 创建一个KElbowVisualizer对象
# k是聚类簇的数量范围
# timings参数设置为True，以便显示训练时间
visualizer = KElbowVisualizer(model, k=(2,30), timings= True)

# 将数据拟合到可视化器中
visualizer.fit(df3)

# 显示可视化结果
visualizer.show()



#Silhouette方法
#Silhouette方法
#Silhouette方法


# 导入所需的库
from sklearn import 训练集sets
from sklearn.metrics import silhouette_score

# 实例化KMeans模型，设置聚类数为5，随机种子为42
km = KMeans(n_clusters=5, random_state=42)

# 使用KMeans模型对数据进行拟合和预测
km.fit_predict(df3)

# 计算轮廓系数
score = silhouette_score(df3, km.labels_, metric='euclidean')

# 打印轮廓系数的平均得分
print('Silhouetter Average Score: %.3f' % score)

# 导入需要的库
from yellowbrick.cluster import SilhouetteVisualizer
# 创建一个图表和子图
fig, ax = plt.subplots(3, 2, figsize=(13,8))
# 设置图表标题
fig.suptitle('Silhouette Analysis for 2-7 Clusters', size = 18)
# 调整子图布局
plt.tight_layout()

# 遍历每个聚类数
for i in [2, 3, 4, 5, 6, 7]:
    '''
    创建一个具有不同聚类数的KMeans实例
    '''
    km = KMeans(n_clusters=i, init='k-means++', n_init=10, max_iter=100, random_state=42)
    # 将子图分为2行3列，获取当前子图的位置
    q, mod = divmod(i, 2)
    '''
    创建一个带有KMeans实例的SilhouetteVisualizer实例
    拟合可视化器
    '''
    visualizer = SilhouetteVisualizer(km, colors='yellowbrick', ax=ax[q-1][mod])
    visualizer.fit(df3)



#系统树图
#系统树图
#系统树图



# 导入所需的库
import scipy.cluster.hierarchy as sch
from matplotlib import pyplot

# 创建一个图形窗口，设置大小为12x5
pyplot.figure(figsize=(12, 5))

# 使用ward方法计算数据集的层次聚类，并生成树状图
dendrogram = sch.dendrogram(sch.linkage(df3, method='ward'))

# 设置图形的标题为"Dendrogram"
plt.title('Dendrogram')

# 设置y轴的标签为"Euclidean distances"
plt.ylabel('Euclidean distances')

# 显示图形
plt.show()



#K-Means
#K-Means
#K-Means
#K-Means
#K-Means


#在数据集上训练K-Means模型
#在数据集上训练K-Means模型
#在数据集上训练K-Means模型



# 复制数据集
# 复制df3数据集到df_kmeans
df_kmeans = df3.copy()

# 复制blob_df数据集到df_blob_kmeans
df_blob_kmeans = blob_df.copy()

# 复制dart_df数据集到df_dart_kmeans
df_dart_kmeans = dart_df.copy()

# 复制basic2_df数据集到df_basic_kmeans
df_basic_kmeans = basic2_df.copy()

# 复制outliers_df数据集到df_outliers_kmeans
df_outliers_kmeans = outliers_df.copy()

# 复制spiral2_df数据集到df_spiral2_kmeans
df_spiral2_kmeans = spiral2_df.copy()

# 复制boxes3_df数据集到df_boxes3_kmeans
df_boxes3_kmeans = boxes3_df.copy()


# 从数据框中删除名为'color'的列
df_blob_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_blob_kmeans数据框中删除名为'color'的列
df_dart_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_dart_kmeans数据框中删除名为'color'的列
df_basic_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_basic_kmeans数据框中删除名为'color'的列
df_outliers_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_outliers_kmeans数据框中删除名为'color'的列
df_spiral2_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_spiral2_kmeans数据框中删除名为'color'的列
df_boxes3_kmeans.drop(['color'], axis=1, inplace=True)  # 在df_boxes3_kmeans数据框中删除名为'color'的列


# 使用KMeans算法进行聚类，将数据分为6个簇，使用k-means++初始化方法，随机种子为42
kmeans = KMeans(n_clusters = 6, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans = kmeans.fit_predict(df_kmeans)

# 使用KMeans算法进行聚类，将数据分为4个簇，使用k-means++初始化方法，随机种子为42
kmeans_blob = KMeans(n_clusters = 4, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_blob = kmeans_blob.fit_predict(df_blob_kmeans)

# 使用KMeans算法进行聚类，将数据分为2个簇，使用k-means++初始化方法，随机种子为42
kmeans_dart = KMeans(n_clusters = 2, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_dart = kmeans_dart.fit_predict(df_dart_kmeans)

# 使用KMeans算法进行聚类，将数据分为5个簇，使用k-means++初始化方法，随机种子为42
kmeans_basic = KMeans(n_clusters = 5, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_basic = kmeans_basic.fit_predict(df_basic_kmeans)

# 使用KMeans算法进行聚类，将数据分为3个簇，使用k-means++初始化方法，随机种子为42
kmeans_outliers = KMeans(n_clusters = 3, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_outliers = kmeans_outliers.fit_predict(df_outliers_kmeans)

# 使用KMeans算法进行聚类，将数据分为2个簇，使用k-means++初始化方法，随机种子为42
kmeans_spiral2 = KMeans(n_clusters = 2, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_spiral2 = kmeans_spiral2.fit_predict(df_spiral2_kmeans)

# 使用KMeans算法进行聚类，将数据分为12个簇，使用k-means++初始化方法，随机种子为42
kmeans_boxes3 = KMeans(n_clusters = 12, init = 'k-means++', random_state = 42)

# 对数据进行聚类，并返回每个样本所属的簇的索引
y_kmeans_boxes3 = kmeans_boxes3.fit_predict(df_boxes3_kmeans)

# 在df_blob_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_blob赋值给该列
df_blob_kmeans['Cluster'] = y_kmeans_blob

# 在df_dart_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_dart赋值给该列
df_dart_kmeans['Cluster'] = y_kmeans_dart

# 在df_basic_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_basic赋值给该列
df_basic_kmeans['Cluster'] = y_kmeans_basic

# 在df_outliers_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_outliers赋值给该列
df_outliers_kmeans['Cluster'] = y_kmeans_outliers

# 在df_spiral2_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_spiral2赋值给该列
df_spiral2_kmeans['Cluster'] = y_kmeans_spiral2

# 在df_boxes3_kmeans数据集中创建名为“Cluster”的列，并将y_kmeans_boxes3赋值给该列
df_boxes3_kmeans['Cluster'] = y_kmeans_boxes3


#比较结果
#比较结果
#比较结果



# 创建子图
fig, axes = plt.subplots(nrows=6, ncols=2,figsize=(10,30))
# 创建一个包含6行2列的子图，总共12个子图，设置整个图的大小为10x30

# 设置总标题
fig.suptitle('ANSWER vs K-Means\n', size = 18)
plt.subplots_adjust(top=2.5)
# 设置总标题为'ANSWER vs K-Means'，字体大小为18

# 绘制Answer Blob子图
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
# 在第1行第1列的子图中绘制散点图，横坐标为blob_df的'x'列，纵坐标为blob_df的'y'列，点的颜色根据blob_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[0,0].set_title("Answer Blob")
# 设置第1行第1列子图的标题为"Answer Blob"

# 绘制K-Means Blob子图
axes[0,1].scatter(df_blob_kmeans['x'], df_blob_kmeans['y'], c=df_blob_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第1行第2列的子图中绘制散点图，横坐标为df_blob_kmeans的'x'列，纵坐标为df_blob_kmeans的'y'列，点的颜色根据df_blob_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[0,1].set_title("K-Means Blob")
# 设置第1行第2列子图的标题为"K-Means Blob"

# 绘制Answer Dart子图
axes[1,0].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
# 在第2行第1列的子图中绘制散点图，横坐标为dart_df的'x'列，纵坐标为dart_df的'y'列，点的颜色根据dart_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[1,0].set_title("Answer Dart")
# 设置第2行第1列子图的标题为"Answer Dart"

# 绘制K-Means Dart子图
axes[1,1].scatter(df_dart_kmeans['x'], df_dart_kmeans['y'], c=df_dart_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第2行第2列的子图中绘制散点图，横坐标为df_dart_kmeans的'x'列，纵坐标为df_dart_kmeans的'y'列，点的颜色根据df_dart_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[1,1].set_title("K-Means Dart")
# 设置第2行第2列子图的标题为"K-Means Dart"

# 绘制Answer Basic子图
axes[2,0].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
# 在第3行第1列的子图中绘制散点图，横坐标为basic2_df的'x'列，纵坐标为basic2_df的'y'列，点的颜色根据basic2_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[2,0].set_title("Answer Basic")
# 设置第3行第1列子图的标题为"Answer Basic"

# 绘制K-Means Basic子图
axes[2,1].scatter(df_basic_kmeans['x'], df_basic_kmeans['y'], c=df_basic_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第3行第2列的子图中绘制散点图，横坐标为df_basic_kmeans的'x'列，纵坐标为df_basic_kmeans的'y'列，点的颜色根据df_basic_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[2,1].set_title("K-Means Basic")
# 设置第3行第2列子图的标题为"K-Means Basic"

# 绘制Answer Outliers子图
axes[3,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
# 在第4行第1列的子图中绘制散点图，横坐标为outliers_df的'x'列，纵坐标为outliers_df的'y'列，点的颜色根据outliers_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[3,0].set_title("Answer Outliers")
# 设置第4行第1列子图的标题为"Answer Outliers"

# 绘制K-Means Outliers子图
axes[3,1].scatter(df_outliers_kmeans['x'], df_outliers_kmeans['y'], c=df_outliers_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第4行第2列的子图中绘制散点图，横坐标为df_outliers_kmeans的'x'列，纵坐标为df_outliers_kmeans的'y'列，点的颜色根据df_outliers_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[3,1].set_title("K-Means Outliers")
# 设置第4行第2列子图的标题为"K-Means Outliers"

# 绘制Answer Spiral子图
axes[4,0].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
# 在第5行第1列的子图中绘制散点图，横坐标为spiral2_df的'x'列，纵坐标为spiral2_df的'y'列，点的颜色根据spiral2_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[4,0].set_title("Answer Spiral")
# 设置第5行第1列子图的标题为"Answer Spiral"

# 绘制K-Means Spiral子图
axes[4,1].scatter(df_spiral2_kmeans['x'], df_spiral2_kmeans['y'], c=df_spiral2_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第5行第2列的子图中绘制散点图，横坐标为df_spiral2_kmeans的'x'列，纵坐标为df_spiral2_kmeans的'y'列，点的颜色根据df_spiral2_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[4,1].set_title("K-Means Spiral")
# 设置第5行第2列子图的标题为"K-Means Spiral"

# 绘制Answer Boxes子图
axes[5,0].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
# 在第6行第1列的子图中绘制散点图，横坐标为boxes3_df的'x'列，纵坐标为boxes3_df的'y'列，点的颜色根据boxes3_df的'color'列确定，点的大小为10，使用"Set3"颜色映射

axes[5,0].set_title("Answer Boxes")
# 设置第6行第1列子图的标题为"Answer Boxes"

# 绘制K-Means Boxes子图
axes[5,1].scatter(df_boxes3_kmeans['x'], df_boxes3_kmeans['y'], c=df_boxes3_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第6行第2列的子图中绘制散点图，横坐标为df_boxes3_kmeans的'x'列，纵坐标为df_boxes3_kmeans的'y'列，点的颜色根据df_boxes3_kmeans的'Cluster'列确定，点的大小为10，使用"Set3"颜色映射

axes[5,1].set_title("K-Means Boxes")
# 设置第6行第2列子图的标题为"K-Means Boxes"

# 调整子图布局
plt.tight_layout()
plt.subplots_adjust(hspace=0.5)

# 调整子图的布局，使得子图之间的间距合适，防止重叠



#在电商数据上使用K-Means算法
#在电商数据上使用K-Means算法
#在电商数据上使用K-Means算法



# 将df2复制给df_kmeans，因为我们需要引用之前的df来添加聚类编号
df_kmeans = df2.copy()

# 检查每个聚类中的项数，并创建一个名为'Cluster'的列
df_kmeans['Cluster'] = y_kmeans

# 统计每个聚类中的项数，并显示结果
cluster_counts=df_kmeans['Cluster'].value_counts()
print(cluster_counts)
# 设置图形大小
plt.figure(figsize=(15,7))

# 绘制散点图
sns.scatterplot(训练集=df_kmeans, x='Amount', y='Frequency', hue='Cluster', s=15, palette="Set3")

# 参数解释：
# 训练集：要绘制的数据集
# x：x轴数据列名
# y：y轴数据列名
# hue：根据该列的值对数据点进行着色
# s：数据点的大小
# palette：颜色调色板，用于设置数据点的颜色



#层次聚类
#层次聚类
#层次聚类
#层次聚类
#层次聚类


#在数据集上训练层次聚类模型
#在数据集上训练层次聚类模型
#在数据集上训练层次聚类模型



# 复制数据集df3并命名为df_AgglomerativeC
df_AgglomerativeC = df3.copy()

# 复制数据集blob_df并命名为df_blob_AgglomerativeC
df_blob_AgglomerativeC = blob_df.copy()

# 复制数据集dart_df并命名为df_dart_AgglomerativeC
df_dart_AgglomerativeC = dart_df.copy()

# 复制数据集basic2_df并命名为df_basic2_AgglomerativeC
df_basic2_AgglomerativeC = basic2_df.copy()

# 复制数据集outliers_df并命名为df_outliers_AgglomerativeC
df_outliers_AgglomerativeC = outliers_df.copy()

# 复制数据集spiral2_df并命名为df_spiral2_AgglomerativeC
df_spiral2_AgglomerativeC = spiral2_df.copy()

# 复制数据集boxes3_df并命名为df_boxes3_AgglomerativeC
df_boxes3_AgglomerativeC = boxes3_df.copy()

# 以下代码是对数据框中的某一列进行删除操作
# df_blob_AgglomerativeC是一个数据框，通过调用drop()函数，删除了名为'color'的列
# inplace=True表示在原数据框上进行修改，而不是返回一个新的数据框

# 删除df_blob_AgglomerativeC数据框中的'color'列
df_blob_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 删除df_dart_AgglomerativeC数据框中的'color'列
df_dart_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 删除df_basic2_AgglomerativeC数据框中的'color'列
df_basic2_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 删除df_outliers_AgglomerativeC数据框中的'color'列
df_outliers_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 删除df_spiral2_AgglomerativeC数据框中的'color'列
df_spiral2_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 删除df_boxes3_AgglomerativeC数据框中的'color'列
df_boxes3_AgglomerativeC.drop(['color'], axis=1, inplace=True)

# 导入AgglomerativeClustering模块
from sklearn.cluster import AgglomerativeClustering

# 创建AgglomerativeClustering对象，设置聚类数为6，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC = AgglomerativeClustering(n_clusters=6, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC对象对数据集df_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC = AgglomerativeC.fit_predict(df_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为4，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_blob = AgglomerativeClustering(n_clusters=4, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_blob对象对数据集df_blob_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_blob = AgglomerativeC_blob.fit_predict(df_blob_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为2，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_dart = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_dart对象对数据集df_dart_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_dart = AgglomerativeC_dart.fit_predict(df_dart_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为5，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_basic = AgglomerativeClustering(n_clusters=5, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_basic对象对数据集df_basic2_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_basic = AgglomerativeC_basic.fit_predict(df_basic2_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为3，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_outliers = AgglomerativeClustering(n_clusters=3, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_outliers对象对数据集df_outliers_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_outliers = AgglomerativeC_outliers.fit_predict(df_outliers_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为2，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_spiral2 = AgglomerativeClustering(n_clusters=2, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_spiral2对象对数据集df_spiral2_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_spiral2 = AgglomerativeC_spiral2.fit_predict(df_spiral2_AgglomerativeC)

# 创建AgglomerativeClustering对象，设置聚类数为12，相似度度量为欧氏距离，链接方式为ward
AgglomerativeC_boxes3 = AgglomerativeClustering(n_clusters=12, affinity='euclidean', linkage='ward')

# 使用AgglomerativeC_boxes3对象对数据集df_boxes3_AgglomerativeC进行聚类，并返回聚类结果
y_AgglomerativeC_boxes3 = AgglomerativeC_boxes3.fit_predict(df_boxes3_AgglomerativeC)

# 在数据集df_blob_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_blob赋值给该列
df_blob_AgglomerativeC['Cluster'] = y_AgglomerativeC_blob

# 在数据集df_dart_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_dart赋值给该列
df_dart_AgglomerativeC['Cluster'] = y_AgglomerativeC_dart

# 在数据集df_basic2_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_basic赋值给该列
df_basic2_AgglomerativeC['Cluster'] = y_AgglomerativeC_basic

# 在数据集df_outliers_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_outliers赋值给该列
df_outliers_AgglomerativeC['Cluster'] = y_AgglomerativeC_outliers

# 在数据集df_spiral2_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_spiral2赋值给该列
df_spiral2_AgglomerativeC['Cluster'] = y_AgglomerativeC_spiral2

# 在数据集df_boxes3_AgglomerativeC中创建'Cluster'列，并将聚类结果y_AgglomerativeC_boxes3赋值给该列
df_boxes3_AgglomerativeC['Cluster'] = y_AgglomerativeC_boxes3




#比较结果
#比较结果
#比较结果



# 创建子图
fig, axes = plt.subplots(nrows=6, ncols=2,figsize=(10,30))
# 创建一个6行2列的子图，总共有12个子图，设置子图的大小为10x30

# 设置总标题
fig.suptitle('ANSWER vs Hierarchical clustering\n', size = 18)
# 设置总标题为'ANSWER vs Hierarchical clustering\n'，字体大小为18

# 绘制Answer Blob散点图
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
# 在第1行第1列的子图中绘制Answer Blob散点图
# x轴数据为blob_df的'x'列，y轴数据为blob_df的'y'列，颜色根据blob_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[0,0].set_title("Answer Blob")
# 设置第1行第1列子图的标题为"Answer Blob"

# 绘制Hierarchical clustering Blob散点图
axes[0,1].scatter(df_blob_AgglomerativeC['x'], df_blob_AgglomerativeC['y'], c=df_blob_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第1行第2列的子图中绘制Hierarchical clustering Blob散点图
# x轴数据为df_blob_AgglomerativeC的'x'列，y轴数据为df_blob_AgglomerativeC的'y'列，颜色根据df_blob_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[0,1].set_title("Hierarchical clustering Blob")
# 设置第1行第2列子图的标题为"Hierarchical clustering Blob"

# 绘制Answer Dart散点图
axes[1,0].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
# 在第2行第1列的子图中绘制Answer Dart散点图
# x轴数据为dart_df的'x'列，y轴数据为dart_df的'y'列，颜色根据dart_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[1,0].set_title("Answer Dart")
# 设置第2行第1列子图的标题为"Answer Dart"

# 绘制Hierarchical clustering Dart散点图
axes[1,1].scatter(df_dart_AgglomerativeC['x'], df_dart_AgglomerativeC['y'], c=df_dart_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第2行第2列的子图中绘制Hierarchical clustering Dart散点图
# x轴数据为df_dart_AgglomerativeC的'x'列，y轴数据为df_dart_AgglomerativeC的'y'列，颜色根据df_dart_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[1,1].set_title("Hierarchical clustering Dart")
# 设置第2行第2列子图的标题为"Hierarchical clustering Dart"

# 绘制Answer Basic散点图
axes[2,0].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
# 在第3行第1列的子图中绘制Answer Basic散点图
# x轴数据为basic2_df的'x'列，y轴数据为basic2_df的'y'列，颜色根据basic2_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[2,0].set_title("Answer Basic")
# 设置第3行第1列子图的标题为"Answer Basic"

# 绘制Hierarchical clustering Basic散点图
axes[2,1].scatter(df_basic2_AgglomerativeC['x'], df_basic2_AgglomerativeC['y'], c=df_basic2_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第3行第2列的子图中绘制Hierarchical clustering Basic散点图
# x轴数据为df_basic2_AgglomerativeC的'x'列，y轴数据为df_basic2_AgglomerativeC的'y'列，颜色根据df_basic2_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[2,1].set_title("Hierarchical clustering Basic")
# 设置第3行第2列子图的标题为"Hierarchical clustering Basic"

# 绘制Answer Outliers散点图
axes[3,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
# 在第4行第1列的子图中绘制Answer Outliers散点图
# x轴数据为outliers_df的'x'列，y轴数据为outliers_df的'y'列，颜色根据outliers_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[3,0].set_title("Answer Outliers")
# 设置第4行第1列子图的标题为"Answer Outliers"

# 绘制Hierarchical clustering Outliers散点图
axes[3,1].scatter(df_outliers_AgglomerativeC['x'], df_outliers_AgglomerativeC['y'], c=df_outliers_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第4行第2列的子图中绘制Hierarchical clustering Outliers散点图
# x轴数据为df_outliers_AgglomerativeC的'x'列，y轴数据为df_outliers_AgglomerativeC的'y'列，颜色根据df_outliers_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[3,1].set_title("Hierarchical clustering Outliers")
# 设置第4行第2列子图的标题为"Hierarchical clustering Outliers"

# 绘制Answer Spiral散点图
axes[4,0].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
# 在第5行第1列的子图中绘制Answer Spiral散点图
# x轴数据为spiral2_df的'x'列，y轴数据为spiral2_df的'y'列，颜色根据spiral2_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[4,0].set_title("Answer Spiral")
# 设置第5行第1列子图的标题为"Answer Spiral"

# 绘制Hierarchical clustering Spiral散点图
axes[4,1].scatter(df_spiral2_AgglomerativeC['x'], df_spiral2_AgglomerativeC['y'], c=df_spiral2_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第5行第2列的子图中绘制Hierarchical clustering Spiral散点图
# x轴数据为df_spiral2_AgglomerativeC的'x'列，y轴数据为df_spiral2_AgglomerativeC的'y'列，颜色根据df_spiral2_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[4,1].set_title("Hierarchical clustering Spiral")
# 设置第5行第2列子图的标题为"Hierarchical clustering Spiral"

# 绘制Answer Boxes散点图
axes[5,0].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
# 在第6行第1列的子图中绘制Answer Boxes散点图
# x轴数据为boxes3_df的'x'列，y轴数据为boxes3_df的'y'列，颜色根据boxes3_df的'color'列确定，点的大小为10，颜色映射为"Set3"

axes[5,0].set_title("Answer Boxes")
# 设置第6行第1列子图的标题为"Answer Boxes"

# 绘制Hierarchical clustering Boxes散点图
axes[5,1].scatter(df_boxes3_AgglomerativeC['x'], df_boxes3_AgglomerativeC['y'], c=df_boxes3_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第6行第2列的子图中绘制Hierarchical clustering Boxes散点图
# x轴数据为df_boxes3_AgglomerativeC的'x'列，y轴数据为df_boxes3_AgglomerativeC的'y'列，颜色根据df_boxes3_AgglomerativeC的'Cluster'列确定，点的大小为10，颜色映射为"Set3"

axes[5,1].set_title("Hierarchical clustering Boxes")
# 设置第6行第2列子图的标题为"Hierarchical clustering Boxes"

# 调整子图布局
plt.tight_layout()
# 调整子图的布局，使得子图之间的间距合适，避免重叠



#在线零售数据的层次聚类
#在线零售数据的层次聚类
#在线零售数据的层次聚类



# 将df2复制给df_AgglomerativeC，因为我们需要引用之前的df来添加聚类号码
df_AgglomerativeC = df2.copy()

# 检查每个聚类中的项数，并创建一个名为'Cluster'的列
df_AgglomerativeC['Cluster'] = y_AgglomerativeC

# 统计每个聚类中的项数
cc=df_AgglomerativeC['Cluster'].value_counts()
print(cc)

# 设置图形大小
plt.figure(figsize=(15,7))

# 绘制散点图
sns.scatterplot(训练集=df_AgglomerativeC, x='Amount', y='Frequency', hue='Cluster', s=15, palette="Set3")

# 添加文注释：设置图形的大小为15x7
# 添加文注释：使用seaborn库的scatterplot函数绘制散点图
# 添加文注释：散点图的x轴数据为'Amount'，y轴数据为'Frequency'
# 添加文注释：根据'Cluster'列的值对散点进行着色
# 添加文注释：散点的大小为15，颜色使用"Set3"调色板




# DBSCAN聚类算法
# DBSCAN聚类算法
# DBSCAN聚类算法
# DBSCAN聚类算法
# DBSCAN聚类算法



# 复制数据集df3并赋值给df_DBScan
df_DBScan = df3.copy()

# 复制数据集blob_df并赋值给df_blob_DBScan
df_blob_DBScan = blob_df.copy()

# 复制数据集dart_df并赋值给df_dart_DBScan
df_dart_DBScan = dart_df.copy()

# 复制数据集basic2_df并赋值给df_basic2_DBScan
df_basic2_DBScan = basic2_df.copy()

# 复制数据集outliers_df并赋值给df_outliers_DBScan
df_outliers_DBScan = outliers_df.copy()

# 复制数据集spiral2_df并赋值给df_spiral2_DBScan
df_spiral2_DBScan = spiral2_df.copy()

# 复制数据集boxes3_df并赋值给df_boxes3_DBScan
df_boxes3_DBScan = boxes3_df.copy()

# 导入NearestNeighbors类
from sklearn.neighbors import NearestNeighbors

# 创建一个NearestNeighbors对象，设置n_neighbors参数为4
nn = NearestNeighbors(n_neighbors=4)

# 使用df_dart_DBScan数据拟合NearestNeighbors模型
nbrs = nn.fit(df_dart_DBScan)

# 使用拟合好的模型计算最近邻的距离和索引
distances, indices = nbrs.kneighbors(df_dart_DBScan)

# 对距离进行排序
distances = np.sort(distances, axis=0)

# 取第二列的距离值
distances = distances[:,1]

# 创建一个6x6的图像
plt.figure(figsize=(6,6))

# 绘制距离图
plt.plot(distances)

# 设置图像标题和坐标轴标签
plt.title('K-distance Graph for "Dart df"',fontsize=20)
plt.xlabel('训练集 Points sorted by distance',fontsize=14)
plt.ylabel('Epsilon',fontsize=14)

# 显示图像
plt.show()



#在数据集上训练DBSCAN聚类模型
#在数据集上训练DBSCAN聚类模型
#在数据集上训练DBSCAN聚类模型



# 删除df_blob_DBScan中的'color'列
df_blob_DBScan.drop(['color'], axis=1, inplace=True)

# 删除df_dart_DBScan中的'color'列
df_dart_DBScan.drop(['color'], axis=1, inplace=True)

# 删除df_basic2_DBScan中的'color'列
df_basic2_DBScan.drop(['color'], axis=1, inplace=True)

# 删除df_outliers_DBScan中的'color'列
df_outliers_DBScan.drop(['color'], axis=1, inplace=True)

# 删除df_spiral2_DBScan中的'color'列
df_spiral2_DBScan.drop(['color'], axis=1, inplace=True)

# 删除df_boxes3_DBScan中的'color'列
df_boxes3_DBScan.drop(['color'], axis=1, inplace=True)

# 导入DBSCAN模型
from sklearn.cluster import DBSCAN

# 创建DBSCAN对象，设置eps为20，min_samples为9，使用欧氏距离作为距离度量
dbscan = DBSCAN(eps=20, min_samples=9, metric='euclidean')

# 使用DBSCAN模型对df_DBScan进行拟合和预测
y_DBScan = dbscan.fit_predict(df_DBScan)

# 创建不同参数的DBSCAN对象
DBScan_blob = DBSCAN(eps=13, min_samples=45, metric='euclidean')
DBScan_dart = DBSCAN(eps=8, min_samples=4, metric='euclidean')
DBScan_basic = DBSCAN(eps=15, min_samples=4, metric='euclidean')
DBScan_outliers = DBSCAN(eps=20, min_samples=4, metric='euclidean')
DBScan_spiral2 = DBSCAN(eps=5.7, min_samples=4, metric='euclidean')
DBScan_boxes3 = DBSCAN(eps=6, min_samples=4, metric='euclidean')

# 使用不同参数的DBSCAN模型对相应的数据集进行拟合和预测
y_DBScan_blob = DBScan_blob.fit_predict(df_blob_DBScan)
y_DBScan_dart = DBScan_dart.fit_predict(df_dart_DBScan)
y_DBScan_basic = DBScan_basic.fit_predict(df_basic2_DBScan)
y_DBScan_outliers = DBScan_outliers.fit_predict(df_outliers_DBScan)
y_DBScan_spiral2 = DBScan_spiral2.fit_predict(df_spiral2_DBScan)
y_DBScan_boxes3 = DBScan_boxes3.fit_predict(df_boxes3_DBScan)

# 在数据集中创建'Cluster'列
df_blob_DBScan['Cluster'] = y_DBScan_blob  # 将DBScan算法聚类结果y_DBScan_blob赋值给df_blob_DBScan的'Cluster'列
df_dart_DBScan['Cluster'] = y_DBScan_dart  # 将DBScan算法聚类结果y_DBScan_dart赋值给df_dart_DBScan的'Cluster'列
df_basic2_DBScan['Cluster'] = y_DBScan_basic  # 将DBScan算法聚类结果y_DBScan_basic赋值给df_basic2_DBScan的'Cluster'列
df_outliers_DBScan['Cluster'] = y_DBScan_outliers  # 将DBScan算法聚类结果y_DBScan_outliers赋值给df_outliers_DBScan的'Cluster'列
df_spiral2_DBScan['Cluster'] = y_DBScan_spiral2  # 将DBScan算法聚类结果y_DBScan_spiral2赋值给df_spiral2_DBScan的'Cluster'列
df_boxes3_DBScan['Cluster'] = y_DBScan_boxes3  # 将DBScan算法聚类结果y_DBScan_boxes3赋值给df_boxes3_DBScan的'Cluster'列

# 上述代码是将DBScan算法聚类结果赋值给数据集中的'Cluster'列，以便后续分析和可视化。每个数据集都有一个对应的聚类结果y_DBScan_xxx，将其赋值给对应的数据集的'Cluster'列即可。




#比较结果
#比较结果
#比较结果



# 导入matplotlib库
import matplotlib.pyplot as plt

# 创建子图fig, axes，其中nrows=6表示创建6行，ncols=2表示创建2列，figsize=(10,30)表示设置子图的大小
fig, axes = plt.subplots(nrows=6, ncols=2, figsize=(10,30))

# 设置总标题fig.suptitle，size=18表示设置标题的字体大小
fig.suptitle('ANSWER vs DBSCAN clustering\n', size = 18)
plt.subplots_adjust(top=2.5)
# 绘制Answer Blob子图，其中c表示颜色，s表示点的大小，cmap表示颜色映射
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
axes[0,0].set_title("Answer Blob") # 设置子图标题

# 绘制DBSCAN clustering Blob子图
axes[0,1].scatter(df_blob_DBScan['x'], df_blob_DBScan['y'], c=df_blob_DBScan['Cluster'], s=10, cmap = "Set3")
axes[0,1].set_title("DBSCAN clustering Blob") # 设置子图标题

# 绘制Answer Dart子图
axes[1,0].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
axes[1,0].set_title("Answer Dart") # 设置子图标题

# 绘制DBSCAN clustering Dart子图
axes[1,1].scatter(df_dart_DBScan['x'], df_dart_DBScan['y'], c=df_dart_DBScan['Cluster'], s=10, cmap = "Set3")
axes[1,1].set_title("DBSCAN clustering Dart") # 设置子图标题

# 绘制Answer Basic子图
axes[2,0].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
axes[2,0].set_title("Answer Basic") # 设置子图标题

# 绘制DBSCAN clustering Basic子图
axes[2,1].scatter(df_basic2_DBScan['x'], df_basic2_DBScan['y'], c=df_basic2_DBScan['Cluster'], s=10, cmap = "Set3")
axes[2,1].set_title("DBSCAN clustering Basic") # 设置子图标题

# 绘制Answer Outliers子图
axes[3,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
axes[3,0].set_title("Answer Outliers") # 设置子图标题

# 绘制DBSCAN clustering Outliers子图
axes[3,1].scatter(df_outliers_DBScan['x'], df_outliers_DBScan['y'], c=df_outliers_DBScan['Cluster'], s=10, cmap = "Set3")
axes[3,1].set_title("DBSCAN clustering Outliers") # 设置子图标题

# 绘制Answer Spiral子图
axes[4,0].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
axes[4,0].set_title("Answer Spiral") # 设置子图标题

# 绘制DBSCAN clustering Spiral子图
axes[4,1].scatter(df_spiral2_DBScan['x'], df_spiral2_DBScan['y'], c=df_spiral2_DBScan['Cluster'], s=10, cmap = "Set3")
axes[4,1].set_title("DBSCAN clustering Spiral") # 设置子图标题

# 绘制Answer Boxes子图
axes[5,0].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
axes[5,0].set_title("Answer Boxes") # 设置子图标题

# 绘制DBSCAN clustering Boxes子图
axes[5,1].scatter(df_boxes3_DBScan['x'], df_boxes3_DBScan['y'], c=df_boxes3_DBScan['Cluster'], s=10, cmap = "Set3")
axes[5,1].set_title("DBSCAN clustering Boxes") # 设置子图标题

# 调整子图布局
plt.tight_layout()



#在在线零售数据上使用DBSCAN聚类模型
#在在线零售数据上使用DBSCAN聚类模型
#在在线零售数据上使用DBSCAN聚类模型



# 复制df2数据框并命名为df_DBScan，因为我们需要引用之前的df数据框来添加聚类编号
df_DBScan = df2.copy()

# 检查每个聚类中的数据项数量，并创建一个名为'Cluster'的列
df_DBScan['Cluster'] = y_DBScan

# 统计每个聚类的数量，并显示在'Cluster'列中
print(df_DBScan['Cluster'].value_counts())

# 设置图形的大小
plt.figure(figsize=(15,7))

# 绘制散点图
sns.scatterplot(训练集=df_DBScan, x='Amount', y='Frequency', hue='Cluster', s=15, palette="Set3")

# 参数解释：
# - 训练集：指定要绘制的数据集
# - x：指定x轴的数据列
# - y：指定y轴的数据列
# - hue：指定用于分组的数据列，根据该列的不同取值，散点图的颜色会有所区分
# - s：指定散点的大小
# - palette：指定颜色的调色板，用于设置散点的颜色




#高斯混合模型（GMM）
#高斯混合模型（GMM）
#高斯混合模型（GMM）
#高斯混合模型（GMM）
#高斯混合模型（GMM）



#训练GMM模型
#训练GMM模型
#训练GMM模型



# 复制数据集df3到df_GMM
df_GMM = df3.copy()

# 复制数据集blob_df到df_blob_GMM
df_blob_GMM = blob_df.copy()

# 复制数据集dart_df到df_dart_GMM
df_dart_GMM = dart_df.copy()

# 复制数据集basic2_df到df_basic2_GMM
df_basic2_GMM = basic2_df.copy()

# 复制数据集outliers_df到df_outliers_GMM
df_outliers_GMM = outliers_df.copy()

# 复制数据集spiral2_df到df_spiral2_GMM
df_spiral2_GMM = spiral2_df.copy()

# 复制数据集boxes3_df到df_boxes3_GMM
df_boxes3_GMM = boxes3_df.copy()

# 给df_blob_GMM数据框删除'color'列
df_blob_GMM.drop(['color'], axis=1, inplace=True)

# 给df_dart_GMM数据框删除'color'列
df_dart_GMM.drop(['color'], axis=1, inplace=True)

# 给df_basic2_GMM数据框删除'color'列
df_basic2_GMM.drop(['color'], axis=1, inplace=True)

# 给df_outliers_GMM数据框删除'color'列
df_outliers_GMM.drop(['color'], axis=1, inplace=True)

# 给df_spiral2_GMM数据框删除'color'列
df_spiral2_GMM.drop(['color'], axis=1, inplace=True)

# 给df_boxes3_GMM数据框删除'color'列
df_boxes3_GMM.drop(['color'], axis=1, inplace=True)

# 导入所需的库
from sklearn.mixture import GaussianMixture

# 创建一个高斯混合模型对象，指定模型的分量数量为8
gmm = GaussianMixture(n_components=8)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM = gmm.fit_predict(df_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为4
GMM_blob = GaussianMixture(n_components=4)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_blob = GMM_blob.fit_predict(df_blob_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为2
GMM_dart = GaussianMixture(n_components=2)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_dart = GMM_dart.fit_predict(df_dart_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为5
GMM_basic = GaussianMixture(n_components=5)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_basic = GMM_basic.fit_predict(df_basic2_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为3
GMM_outliers = GaussianMixture(n_components=3)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_outliers = GMM_outliers.fit_predict(df_outliers_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为2
GMM_spiral2 = GaussianMixture(n_components=2)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_spiral2 = GMM_spiral2.fit_predict(df_spiral2_GMM)

# 创建高斯混合模型对象，指定模型的分量数量为12
GMM_boxes3 = GaussianMixture(n_components=12)

# 使用高斯混合模型对数据进行拟合和预测，得到预测结果
y_GMM_boxes3 = GMM_boxes3.fit_predict(df_boxes3_GMM)


# 在数据集df_blob_GMM中创建一个名为"Cluster"的列
df_blob_GMM['Cluster'] = y_GMM_blob  
# 将GMM聚类算法的结果y_GMM_blob赋值给df_blob_GMM数据集的"Cluster"列

# 在数据集df_dart_GMM中创建一个名为"Cluster"的列
df_dart_GMM['Cluster'] = y_GMM_dart  
# 将GMM聚类算法的结果y_GMM_dart赋值给df_dart_GMM数据集的"Cluster"列

# 在数据集df_basic2_GMM中创建一个名为"Cluster"的列
df_basic2_GMM['Cluster'] = y_GMM_basic  
# 将GMM聚类算法的结果y_GMM_basic赋值给df_basic2_GMM数据集的"Cluster"列

# 在数据集df_outliers_GMM中创建一个名为"Cluster"的列
df_outliers_GMM['Cluster'] = y_GMM_outliers  
# 将GMM聚类算法的结果y_GMM_outliers赋值给df_outliers_GMM数据集的"Cluster"列

# 在数据集df_spiral2_GMM中创建一个名为"Cluster"的列
df_spiral2_GMM['Cluster'] = y_GMM_spiral2  
# 将GMM聚类算法的结果y_GMM_spiral2赋值给df_spiral2_GMM数据集的"Cluster"列

# 在数据集df_boxes3_GMM中创建一个名为"Cluster"的列
df_boxes3_GMM['Cluster'] = y_GMM_boxes3  
# 将GMM聚类算法的结果y_GMM_boxes3赋值给df_boxes3_GMM数据集的"Cluster"列

# 创建子图fig, axes，其中nrows=6表示子图行数为6，ncols=2表示子图列数为2，figsize=(10,30)表示整个图的大小为10*30
fig, axes = plt.subplots(nrows=6, ncols=2, figsize=(10,30))

# 设置整个图的标题为'ANSWER vs GMM clustering\n'，字体大小为18
fig.suptitle('ANSWER vs GMM clustering\n', size = 18)
plt.subplots_adjust(top=2.5)
# 绘制第一个子图，显示Answer Blob的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
axes[0,0].set_title("Answer Blob") # 设置子图标题为"Answer Blob"

# 绘制第二个子图，显示GMM clustering Blob的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[0,1].scatter(df_blob_GMM['x'], df_blob_GMM['y'], c=df_blob_GMM['Cluster'], s=10, cmap = "Set3")
axes[0,1].set_title("GMM clustering Blob") # 设置子图标题为"GMM clustering Blob"

# 绘制第三个子图，显示Answer Dart的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[1,0].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
axes[1,0].set_title("Answer Dart") # 设置子图标题为"Answer Dart"

# 绘制第四个子图，显示GMM clustering Dart的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[1,1].scatter(df_dart_GMM['x'], df_dart_GMM['y'], c=df_dart_GMM['Cluster'], s=10, cmap = "Set3")
axes[1,1].set_title("GMM clustering Dart") # 设置子图标题为"GMM clustering Dart"

# 绘制第五个子图，显示Answer Basic的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[2,0].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
axes[2,0].set_title("Answer Basic") # 设置子图标题为"Answer Basic"

# 绘制第六个子图，显示GMM clustering Basic的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[2,1].scatter(df_basic2_GMM['x'], df_basic2_GMM['y'], c=df_basic2_GMM['Cluster'], s=10, cmap = "Set3")
axes[2,1].set_title("GMM clustering Basic") # 设置子图标题为"GMM clustering Basic"

# 绘制第七个子图，显示Answer Outliers的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[3,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
axes[3,0].set_title("Answer Outliers") # 设置子图标题为"Answer Outliers"

# 绘制第八个子图，显示GMM clustering Outliers的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[3,1].scatter(df_outliers_GMM['x'], df_outliers_GMM['y'], c=df_outliers_GMM['Cluster'], s=10, cmap = "Set3")
axes[3,1].set_title("GMM clustering Outliers") # 设置子图标题为"GMM clustering Outliers"

# 绘制第九个子图，显示Answer Spiral的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[4,0].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
axes[4,0].set_title("Answer Spiral") # 设置子图标题为"Answer Spiral"

# 绘制第十个子图，显示GMM clustering Spiral的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[4,1].scatter(df_spiral2_GMM['x'], df_spiral2_GMM['y'], c=df_spiral2_GMM['Cluster'], s=10, cmap = "Set3")
axes[4,1].set_title("GMM clustering Spiral") # 设置子图标题为"GMM clustering Spiral"

# 绘制第十一个子图，显示Answer Boxes的散点图，其中x、y、color分别表示数据的横坐标、纵坐标和颜色，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[5,0].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
axes[5,0].set_title("Answer Boxes") # 设置子图标题为"Answer Boxes"

# 绘制第十二个子图，显示GMM clustering Boxes的散点图，其中x、y、Cluster分别表示数据的横坐标、纵坐标和聚类结果，s=10表示散点的大小为10，cmap="Set3"表示使用Set3颜色映射
axes[5,1].scatter(df_boxes3_GMM['x'], df_boxes3_GMM['y'], c=df_boxes3_GMM['Cluster'], s=10, cmap = "Set3")
axes[5,1].set_title("GMM clustering Boxes") # 设置子图标题为"GMM clustering Boxes"

# 调整子图的布局
plt.tight_layout()
plt.subplots_adjust(hspace=0.5)



#电商数据的GMM聚类模型
#电商数据的GMM聚类模型
#电商数据的GMM聚类模型



# 将df2复制给df_GMM，因为我们需要引用之前的df来添加聚类编号
df_GMM = df2.copy()

# 检查每个聚类中的项数，并创建一个名为'Cluster'的列
df_GMM['Cluster'] = y_GMM

# 统计每个聚类中的项数，并显示出来
print(df_GMM['Cluster'].value_counts())


# 设置图形的大小
plt.figure(figsize=(15,7))

# 绘制散点图
sns.scatterplot(训练集=df_GMM, x='Amount', y='Frequency', hue='Cluster', s=15, palette="Set3")

# 参数说明：
# 训练集：要绘制的数据集
# x：x轴的数据列
# y：y轴的数据列
# hue：根据该列的值对数据点进行着色
# s：数据点的大小
# palette：颜色调色板，用于设置数据点的颜色




#所有算法比较
#所有算法比较
#所有算法比较
#所有算法比较
#所有算法比较



# 创建子图fig, axes = plt.subplots(nrows=6, ncols=5,figsize=(30,30))
fig, axes = plt.subplots(nrows=6, ncols=5,figsize=(30,30))

# 创建一个6行5列的子图，设置整个图的大小为30x30

# 设置总标题fig.suptitle('ANSWER vs different algorithm\n', size = 18)
fig.suptitle('ANSWER vs different algorithm\n', size = 18)
plt.subplots_adjust(top=5)
# 设置总标题为'ANSWER vs different algorithm'，字体大小为18


# 绘制Answer Blob散点图
axes[0,0].scatter(blob_df['x'], blob_df['y'], c=blob_df['color'], s=10, cmap = "Set3")
# 在第1行第1列的子图中绘制Answer Blob的散点图

# x轴数据为blob_df的x列，y轴数据为blob_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[0,0].set_title("Answer Blob")
# 设置该子图的标题为"Answer Blob"

# 绘制GMM clustering Blob散点图
axes[0,1].scatter(df_blob_GMM['x'], df_blob_GMM['y'], c=df_blob_GMM['Cluster'], s=10, cmap = "Set3")
# 在第1行第2列的子图中绘制GMM clustering Blob的散点图
# x轴数据为df_blob_GMM的x列，y轴数据为df_blob_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[0,1].set_title("GMM clustering Blob")
# 设置该子图的标题为"GMM clustering Blob"

# 绘制K-Means Blob散点图
axes[0,2].scatter(df_blob_kmeans['x'], df_blob_kmeans['y'], c=df_blob_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第1行第3列的子图中绘制K-Means Blob的散点图
# x轴数据为df_blob_kmeans的x列，y轴数据为df_blob_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[0,2].set_title("K-Means Blob")
# 设置该子图的标题为"K-Means Blob"

# 绘制Hierarchical clustering Blob散点图
axes[0,3].scatter(df_blob_AgglomerativeC['x'], df_blob_AgglomerativeC['y'], c=df_blob_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第1行第4列的子图中绘制Hierarchical clustering Blob的散点图
# x轴数据为df_blob_AgglomerativeC的x列，y轴数据为df_blob_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[0,3].set_title("Hierarchical clustering Blob")
# 设置该子图的标题为"Hierarchical clustering Blob"

# 绘制DBSCAN clustering Blob散点图
axes[0,4].scatter(df_blob_DBScan['x'], df_blob_DBScan['y'], c=df_blob_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第1行第5列的子图中绘制DBSCAN clustering Blob的散点图
# x轴数据为df_blob_DBScan的x列，y轴数据为df_blob_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[0,4].set_title("DBSCAN clustering Blob")
# 设置该子图的标题为"DBSCAN clustering Blob"

# 绘制Answer Dart散点图
axes[1,0].scatter(dart_df['x'], dart_df['y'], c=dart_df['color'], s=10, cmap = "Set3")
# 在第2行第1列的子图中绘制Answer Dart的散点图
# x轴数据为dart_df的x列，y轴数据为dart_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[1,0].set_title("Answer Dart")
# 设置该子图的标题为"Answer Dart"

# 绘制GMM clustering Dart散点图
axes[1,1].scatter(df_dart_GMM['x'], df_dart_GMM['y'], c=df_dart_GMM['Cluster'], s=10, cmap = "Set3")
# 在第2行第2列的子图中绘制GMM clustering Dart的散点图
# x轴数据为df_dart_GMM的x列，y轴数据为df_dart_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[1,1].set_title("GMM clustering Dart")
# 设置该子图的标题为"GMM clustering Dart"

# 绘制K-Means Dart散点图
axes[1,2].scatter(df_dart_kmeans['x'], df_dart_kmeans['y'], c=df_dart_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第2行第3列的子图中绘制K-Means Dart的散点图
# x轴数据为df_dart_kmeans的x列，y轴数据为df_dart_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[1,2].set_title("K-Means Dart")
# 设置该子图的标题为"K-Means Dart"

# 绘制Hierarchical clustering Dart散点图
axes[1,3].scatter(df_dart_AgglomerativeC['x'], df_dart_AgglomerativeC['y'], c=df_dart_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第2行第4列的子图中绘制Hierarchical clustering Dart的散点图
# x轴数据为df_dart_AgglomerativeC的x列，y轴数据为df_dart_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[1,3].set_title("Hierarchical clustering Dart")
# 设置该子图的标题为"Hierarchical clustering Dart"

# 绘制DBSCAN clustering Dart散点图
axes[1,4].scatter(df_dart_DBScan['x'], df_dart_DBScan['y'], c=df_dart_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第2行第5列的子图中绘制DBSCAN clustering Dart的散点图
# x轴数据为df_dart_DBScan的x列，y轴数据为df_dart_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[1,4].set_title("DBSCAN clustering Dart")
# 设置该子图的标题为"DBSCAN clustering Dart"

# 绘制Answer Basic散点图
axes[2,0].scatter(basic2_df['x'], basic2_df['y'], c=basic2_df['color'], s=10, cmap = "Set3")
# 在第3行第1列的子图中绘制Answer Basic的散点图
# x轴数据为basic2_df的x列，y轴数据为basic2_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[2,0].set_title("Answer Basic")
# 设置该子图的标题为"Answer Basic"

# 绘制GMM clustering Basic散点图
axes[2,1].scatter(df_basic2_GMM['x'], df_basic2_GMM['y'], c=df_basic2_GMM['Cluster'], s=10, cmap = "Set3")
# 在第3行第2列的子图中绘制GMM clustering Basic的散点图
# x轴数据为df_basic2_GMM的x列，y轴数据为df_basic2_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[2,1].set_title("GMM clustering Basic")
# 设置该子图的标题为"GMM clustering Basic"

# 绘制K-Means Basic散点图
axes[2,2].scatter(df_basic_kmeans['x'], df_basic_kmeans['y'], c=df_basic_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第3行第3列的子图中绘制K-Means Basic的散点图
# x轴数据为df_basic_kmeans的x列，y轴数据为df_basic_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[2,2].set_title("K-Means Basic")
# 设置该子图的标题为"K-Means Basic"

# 绘制Hierarchical clustering Basic散点图
axes[2,3].scatter(df_basic2_AgglomerativeC['x'], df_basic2_AgglomerativeC['y'], c=df_basic2_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第3行第4列的子图中绘制Hierarchical clustering Basic的散点图
# x轴数据为df_basic2_AgglomerativeC的x列，y轴数据为df_basic2_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[2,3].set_title("Hierarchical clustering Basic")
# 设置该子图的标题为"Hierarchical clustering Basic"

# 绘制DBSCAN clustering Basic散点图
axes[2,4].scatter(df_basic2_DBScan['x'], df_basic2_DBScan['y'], c=df_basic2_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第3行第5列的子图中绘制DBSCAN clustering Basic的散点图
# x轴数据为df_basic2_DBScan的x列，y轴数据为df_basic2_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[2,4].set_title("DBSCAN clustering Basic")
# 设置该子图的标题为"DBSCAN clustering Basic"

# 绘制Answer Outliers散点图
axes[3,0].scatter(outliers_df['x'], outliers_df['y'], c=outliers_df['color'], s=10, cmap = "Set3")
# 在第4行第1列的子图中绘制Answer Outliers的散点图
# x轴数据为outliers_df的x列，y轴数据为outliers_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[3,0].set_title("Answer Outliers")
# 设置该子图的标题为"Answer Outliers"

# 绘制GMM clustering Outliers散点图
axes[3,1].scatter(df_outliers_GMM['x'], df_outliers_GMM['y'], c=df_outliers_GMM['Cluster'], s=10, cmap = "Set3")
# 在第4行第2列的子图中绘制GMM clustering Outliers的散点图
# x轴数据为df_outliers_GMM的x列，y轴数据为df_outliers_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[3,1].set_title("GMM clustering Outliers")
# 设置该子图的标题为"GMM clustering Outliers"

# 绘制K-Means Outliers散点图
axes[3,2].scatter(df_outliers_kmeans['x'], df_outliers_kmeans['y'], c=df_outliers_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第4行第3列的子图中绘制K-Means Outliers的散点图
# x轴数据为df_outliers_kmeans的x列，y轴数据为df_outliers_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[3,2].set_title("K-Means Outliers")
# 设置该子图的标题为"K-Means Outliers"

# 绘制Hierarchical clustering Outliers散点图
axes[3,3].scatter(df_outliers_AgglomerativeC['x'], df_outliers_AgglomerativeC['y'], c=df_outliers_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第4行第4列的子图中绘制Hierarchical clustering Outliers的散点图
# x轴数据为df_outliers_AgglomerativeC的x列，y轴数据为df_outliers_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[3,3].set_title("Hierarchical clustering Outliers")
# 设置该子图的标题为"Hierarchical clustering Outliers"

# 绘制DBSCAN clustering Outliers散点图
axes[3,4].scatter(df_outliers_DBScan['x'], df_outliers_DBScan['y'], c=df_outliers_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第4行第5列的子图中绘制DBSCAN clustering Outliers的散点图
# x轴数据为df_outliers_DBScan的x列，y轴数据为df_outliers_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[3,4].set_title("DBSCAN clustering Outliers")
# 设置该子图的标题为"DBSCAN clustering Outliers"

# 绘制Answer Spiral散点图
axes[4,0].scatter(spiral2_df['x'], spiral2_df['y'], c=spiral2_df['color'], s=10, cmap = "Set3")
# 在第5行第1列的子图中绘制Answer Spiral的散点图
# x轴数据为spiral2_df的x列，y轴数据为spiral2_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[4,0].set_title("Answer Spiral")
# 设置该子图的标题为"Answer Spiral"

# 绘制GMM clustering Spiral散点图
axes[4,1].scatter(df_spiral2_GMM['x'], df_spiral2_GMM['y'], c=df_spiral2_GMM['Cluster'], s=10, cmap = "Set3")
# 在第5行第2列的子图中绘制GMM clustering Spiral的散点图
# x轴数据为df_spiral2_GMM的x列，y轴数据为df_spiral2_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[4,1].set_title("GMM clustering Spiral")
# 设置该子图的标题为"GMM clustering Spiral"

# 绘制K-Means Spiral散点图
axes[4,2].scatter(df_spiral2_kmeans['x'], df_spiral2_kmeans['y'], c=df_spiral2_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第5行第3列的子图中绘制K-Means Spiral的散点图
# x轴数据为df_spiral2_kmeans的x列，y轴数据为df_spiral2_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[4,2].set_title("K-Means Spiral")
# 设置该子图的标题为"K-Means Spiral"

# 绘制Hierarchical clustering Spiral散点图
axes[4,3].scatter(df_spiral2_AgglomerativeC['x'], df_spiral2_AgglomerativeC['y'], c=df_spiral2_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第5行第4列的子图中绘制Hierarchical clustering Spiral的散点图
# x轴数据为df_spiral2_AgglomerativeC的x列，y轴数据为df_spiral2_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[4,3].set_title("Hierarchical clustering Spiral")
# 设置该子图的标题为"Hierarchical clustering Spiral"

# 绘制DBSCAN clustering Spiral散点图
axes[4,4].scatter(df_spiral2_DBScan['x'], df_spiral2_DBScan['y'], c=df_spiral2_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第5行第5列的子图中绘制DBSCAN clustering Spiral的散点图
# x轴数据为df_spiral2_DBScan的x列，y轴数据为df_spiral2_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[4,4].set_title("DBSCAN clustering Spiral")
# 设置该子图的标题为"DBSCAN clustering Spiral"

# 绘制Answer Boxes散点图
axes[5,0].scatter(boxes3_df['x'], boxes3_df['y'], c=boxes3_df['color'], s=10, cmap = "Set3")
# 在第6行第1列的子图中绘制Answer Boxes的散点图
# x轴数据为boxes3_df的x列，y轴数据为boxes3_df的y列，颜色根据color列的值确定，点的大小为10，颜色映射为"Set3"
axes[5,0].set_title("Answer Boxes")
# 设置该子图的标题为"Answer Boxes"

# 绘制GMM clustering Boxes散点图
axes[5,1].scatter(df_boxes3_GMM['x'], df_boxes3_GMM['y'], c=df_boxes3_GMM['Cluster'], s=10, cmap = "Set3")
# 在第6行第2列的子图中绘制GMM clustering Boxes的散点图
# x轴数据为df_boxes3_GMM的x列，y轴数据为df_boxes3_GMM的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[5,1].set_title("GMM clustering Boxes")
# 设置该子图的标题为"GMM clustering Boxes"

# 绘制K-Means Boxes散点图
axes[5,2].scatter(df_boxes3_kmeans['x'], df_boxes3_kmeans['y'], c=df_boxes3_kmeans['Cluster'], s=10, cmap = "Set3")
# 在第6行第3列的子图中绘制K-Means Boxes的散点图
# x轴数据为df_boxes3_kmeans的x列，y轴数据为df_boxes3_kmeans的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[5,2].set_title("K-Means Boxes")
# 设置该子图的标题为"K-Means Boxes"

# 绘制Hierarchical clustering Boxes散点图
axes[5,3].scatter(df_boxes3_AgglomerativeC['x'], df_boxes3_AgglomerativeC['y'], c=df_boxes3_AgglomerativeC['Cluster'], s=10, cmap = "Set3")
# 在第6行第4列的子图中绘制Hierarchical clustering Boxes的散点图
# x轴数据为df_boxes3_AgglomerativeC的x列，y轴数据为df_boxes3_AgglomerativeC的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[5,3].set_title("Hierarchical clustering Boxes")
# 设置该子图的标题为"Hierarchical clustering Boxes"

# 绘制DBSCAN clustering Boxes散点图
axes[5,4].scatter(df_boxes3_DBScan['x'], df_boxes3_DBScan['y'], c=df_boxes3_DBScan['Cluster'], s=10, cmap = "Set3")
# 在第6行第5列的子图中绘制DBSCAN clustering Boxes的散点图
# x轴数据为df_boxes3_DBScan的x列，y轴数据为df_boxes3_DBScan的y列，颜色根据Cluster列的值确定，点的大小为10，颜色映射为"Set3"
axes[5,4].set_title("DBSCAN clustering Boxes")
# 设置该子图的标题为"DBSCAN clustering Boxes"



# 调整子图的布局，使得子图之间的间距合适，防止重叠
plt.tight_layout(rect=[0, 0, 1, 0.95])
# 调整子图和标题之间的距离
plt.subplots_adjust(top=0.95, hspace=0.7)
plt.show()